/*
 * XML Type:  XInputUnit
 * Namespace: http://www.seedwill.com/xul/widget/
 * Java type: com.seedwill.xul.widget.XInputUnit
 *
 * Automatically generated - do not modify.
 */
package com.seedwill.xul.widget.impl;
/**
 * An XML XInputUnit(@http://www.seedwill.com/xul/widget/).
 *
 * This is a complex type.
 */
public class XInputUnitImpl extends com.seedwill.xul.core.impl.XIdentifiedImpl implements com.seedwill.xul.widget.XInputUnit
{
    private static final long serialVersionUID = 1L;
    
    public XInputUnitImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName SORT$0 = 
        new javax.xml.namespace.QName("", "sort");
    private static final javax.xml.namespace.QName CTLS$2 = 
        new javax.xml.namespace.QName("", "ctls");
    private static final javax.xml.namespace.QName ORIENT$4 = 
        new javax.xml.namespace.QName("", "orient");
    private static final javax.xml.namespace.QName CHILDREN$6 = 
        new javax.xml.namespace.QName("", "children");
    private static final javax.xml.namespace.QName LABEL$8 = 
        new javax.xml.namespace.QName("", "label");
    private static final javax.xml.namespace.QName MONOFLAG$10 = 
        new javax.xml.namespace.QName("", "monoFlag");
    private static final javax.xml.namespace.QName SCHEMAOUT$12 = 
        new javax.xml.namespace.QName("", "schemaOut");
    private static final javax.xml.namespace.QName SCHEMAOUTTYPE$14 = 
        new javax.xml.namespace.QName("", "schemaOutType");
    private static final javax.xml.namespace.QName ADAPTOROUT$16 = 
        new javax.xml.namespace.QName("", "adaptorOut");
    private static final javax.xml.namespace.QName ADAPTOROUTTYPE$18 = 
        new javax.xml.namespace.QName("", "adaptorOutType");
    private static final javax.xml.namespace.QName SCHEMAIN$20 = 
        new javax.xml.namespace.QName("", "schemaIn");
    private static final javax.xml.namespace.QName SCHEMAINTYPE$22 = 
        new javax.xml.namespace.QName("", "schemaInType");
    private static final javax.xml.namespace.QName ADAPTORIN$24 = 
        new javax.xml.namespace.QName("", "adaptorIn");
    private static final javax.xml.namespace.QName ADAPTORINTYPE$26 = 
        new javax.xml.namespace.QName("", "adaptorInType");
    
    
    /**
     * Gets the "sort" element
     */
    public int getSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SORT$0, 0);
            if (target == null)
            {
                return 0;
            }
            return target.getIntValue();
        }
    }
    
    /**
     * Gets (as xml) the "sort" element
     */
    public org.apache.xmlbeans.XmlInt xgetSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlInt target = null;
            target = (org.apache.xmlbeans.XmlInt)get_store().find_element_user(SORT$0, 0);
            return target;
        }
    }
    
    /**
     * True if has "sort" element
     */
    public boolean isSetSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SORT$0) != 0;
        }
    }
    
    /**
     * Sets the "sort" element
     */
    public void setSort(int sort)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SORT$0, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SORT$0);
            }
            target.setIntValue(sort);
        }
    }
    
    /**
     * Sets (as xml) the "sort" element
     */
    public void xsetSort(org.apache.xmlbeans.XmlInt sort)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlInt target = null;
            target = (org.apache.xmlbeans.XmlInt)get_store().find_element_user(SORT$0, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlInt)get_store().add_element_user(SORT$0);
            }
            target.set(sort);
        }
    }
    
    /**
     * Unsets the "sort" element
     */
    public void unsetSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SORT$0, 0);
        }
    }
    
    /**
     * Gets array of all "ctls" elements
     */
    public com.seedwill.xul.widget.XControl[] getCtlsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CTLS$2, targetList);
            com.seedwill.xul.widget.XControl[] result = new com.seedwill.xul.widget.XControl[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "ctls" element
     */
    public com.seedwill.xul.widget.XControl getCtlsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XControl target = null;
            target = (com.seedwill.xul.widget.XControl)get_store().find_element_user(CTLS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "ctls" element
     */
    public int sizeOfCtlsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CTLS$2);
        }
    }
    
    /**
     * Sets array of all "ctls" element
     */
    public void setCtlsArray(com.seedwill.xul.widget.XControl[] ctlsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(ctlsArray, CTLS$2);
        }
    }
    
    /**
     * Sets ith "ctls" element
     */
    public void setCtlsArray(int i, com.seedwill.xul.widget.XControl ctls)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XControl target = null;
            target = (com.seedwill.xul.widget.XControl)get_store().find_element_user(CTLS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(ctls);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "ctls" element
     */
    public com.seedwill.xul.widget.XControl insertNewCtls(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XControl target = null;
            target = (com.seedwill.xul.widget.XControl)get_store().insert_element_user(CTLS$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "ctls" element
     */
    public com.seedwill.xul.widget.XControl addNewCtls()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XControl target = null;
            target = (com.seedwill.xul.widget.XControl)get_store().add_element_user(CTLS$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "ctls" element
     */
    public void removeCtls(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CTLS$2, i);
        }
    }
    
    /**
     * Gets the "orient" element
     */
    public com.seedwill.xul.core.XOrient.Enum getOrient()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ORIENT$4, 0);
            if (target == null)
            {
                return null;
            }
            return (com.seedwill.xul.core.XOrient.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "orient" element
     */
    public com.seedwill.xul.core.XOrient xgetOrient()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XOrient target = null;
            target = (com.seedwill.xul.core.XOrient)get_store().find_element_user(ORIENT$4, 0);
            return target;
        }
    }
    
    /**
     * True if has "orient" element
     */
    public boolean isSetOrient()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ORIENT$4) != 0;
        }
    }
    
    /**
     * Sets the "orient" element
     */
    public void setOrient(com.seedwill.xul.core.XOrient.Enum orient)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ORIENT$4, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ORIENT$4);
            }
            target.setEnumValue(orient);
        }
    }
    
    /**
     * Sets (as xml) the "orient" element
     */
    public void xsetOrient(com.seedwill.xul.core.XOrient orient)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XOrient target = null;
            target = (com.seedwill.xul.core.XOrient)get_store().find_element_user(ORIENT$4, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XOrient)get_store().add_element_user(ORIENT$4);
            }
            target.set(orient);
        }
    }
    
    /**
     * Unsets the "orient" element
     */
    public void unsetOrient()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ORIENT$4, 0);
        }
    }
    
    /**
     * Gets array of all "children" elements
     */
    public com.seedwill.xul.widget.XInputUnit[] getChildrenArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CHILDREN$6, targetList);
            com.seedwill.xul.widget.XInputUnit[] result = new com.seedwill.xul.widget.XInputUnit[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "children" element
     */
    public com.seedwill.xul.widget.XInputUnit getChildrenArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().find_element_user(CHILDREN$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "children" element
     */
    public int sizeOfChildrenArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CHILDREN$6);
        }
    }
    
    /**
     * Sets array of all "children" element
     */
    public void setChildrenArray(com.seedwill.xul.widget.XInputUnit[] childrenArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(childrenArray, CHILDREN$6);
        }
    }
    
    /**
     * Sets ith "children" element
     */
    public void setChildrenArray(int i, com.seedwill.xul.widget.XInputUnit children)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().find_element_user(CHILDREN$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(children);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "children" element
     */
    public com.seedwill.xul.widget.XInputUnit insertNewChildren(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().insert_element_user(CHILDREN$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "children" element
     */
    public com.seedwill.xul.widget.XInputUnit addNewChildren()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().add_element_user(CHILDREN$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "children" element
     */
    public void removeChildren(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CHILDREN$6, i);
        }
    }
    
    /**
     * Gets the "label" element
     */
    public com.seedwill.xul.widget.XLabel getLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XLabel target = null;
            target = (com.seedwill.xul.widget.XLabel)get_store().find_element_user(LABEL$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "label" element
     */
    public boolean isSetLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LABEL$8) != 0;
        }
    }
    
    /**
     * Sets the "label" element
     */
    public void setLabel(com.seedwill.xul.widget.XLabel label)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XLabel target = null;
            target = (com.seedwill.xul.widget.XLabel)get_store().find_element_user(LABEL$8, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.widget.XLabel)get_store().add_element_user(LABEL$8);
            }
            target.set(label);
        }
    }
    
    /**
     * Appends and returns a new empty "label" element
     */
    public com.seedwill.xul.widget.XLabel addNewLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XLabel target = null;
            target = (com.seedwill.xul.widget.XLabel)get_store().add_element_user(LABEL$8);
            return target;
        }
    }
    
    /**
     * Unsets the "label" element
     */
    public void unsetLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LABEL$8, 0);
        }
    }
    
    /**
     * Gets the "monoFlag" element
     */
    public boolean getMonoFlag()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(MONOFLAG$10, 0);
            if (target == null)
            {
                return false;
            }
            return target.getBooleanValue();
        }
    }
    
    /**
     * Gets (as xml) the "monoFlag" element
     */
    public org.apache.xmlbeans.XmlBoolean xgetMonoFlag()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlBoolean target = null;
            target = (org.apache.xmlbeans.XmlBoolean)get_store().find_element_user(MONOFLAG$10, 0);
            return target;
        }
    }
    
    /**
     * True if has "monoFlag" element
     */
    public boolean isSetMonoFlag()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MONOFLAG$10) != 0;
        }
    }
    
    /**
     * Sets the "monoFlag" element
     */
    public void setMonoFlag(boolean monoFlag)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(MONOFLAG$10, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(MONOFLAG$10);
            }
            target.setBooleanValue(monoFlag);
        }
    }
    
    /**
     * Sets (as xml) the "monoFlag" element
     */
    public void xsetMonoFlag(org.apache.xmlbeans.XmlBoolean monoFlag)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlBoolean target = null;
            target = (org.apache.xmlbeans.XmlBoolean)get_store().find_element_user(MONOFLAG$10, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlBoolean)get_store().add_element_user(MONOFLAG$10);
            }
            target.set(monoFlag);
        }
    }
    
    /**
     * Unsets the "monoFlag" element
     */
    public void unsetMonoFlag()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MONOFLAG$10, 0);
        }
    }
    
    /**
     * Gets the "schemaOut" element
     */
    public java.lang.String getSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUT$12, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaOut" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUT$12, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaOut" element
     */
    public boolean isSetSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAOUT$12) != 0;
        }
    }
    
    /**
     * Sets the "schemaOut" element
     */
    public void setSchemaOut(java.lang.String schemaOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUT$12, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAOUT$12);
            }
            target.setStringValue(schemaOut);
        }
    }
    
    /**
     * Sets (as xml) the "schemaOut" element
     */
    public void xsetSchemaOut(org.apache.xmlbeans.XmlString schemaOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUT$12, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAOUT$12);
            }
            target.set(schemaOut);
        }
    }
    
    /**
     * Unsets the "schemaOut" element
     */
    public void unsetSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAOUT$12, 0);
        }
    }
    
    /**
     * Gets the "schemaOutType" element
     */
    public java.lang.String getSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUTTYPE$14, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaOutType" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUTTYPE$14, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaOutType" element
     */
    public boolean isSetSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAOUTTYPE$14) != 0;
        }
    }
    
    /**
     * Sets the "schemaOutType" element
     */
    public void setSchemaOutType(java.lang.String schemaOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUTTYPE$14, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAOUTTYPE$14);
            }
            target.setStringValue(schemaOutType);
        }
    }
    
    /**
     * Sets (as xml) the "schemaOutType" element
     */
    public void xsetSchemaOutType(org.apache.xmlbeans.XmlString schemaOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUTTYPE$14, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAOUTTYPE$14);
            }
            target.set(schemaOutType);
        }
    }
    
    /**
     * Unsets the "schemaOutType" element
     */
    public void unsetSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAOUTTYPE$14, 0);
        }
    }
    
    /**
     * Gets the "adaptorOut" element
     */
    public java.lang.String getAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUT$16, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorOut" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUT$16, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorOut" element
     */
    public boolean isSetAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTOROUT$16) != 0;
        }
    }
    
    /**
     * Sets the "adaptorOut" element
     */
    public void setAdaptorOut(java.lang.String adaptorOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUT$16, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTOROUT$16);
            }
            target.setStringValue(adaptorOut);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorOut" element
     */
    public void xsetAdaptorOut(org.apache.xmlbeans.XmlString adaptorOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUT$16, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTOROUT$16);
            }
            target.set(adaptorOut);
        }
    }
    
    /**
     * Unsets the "adaptorOut" element
     */
    public void unsetAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTOROUT$16, 0);
        }
    }
    
    /**
     * Gets the "adaptorOutType" element
     */
    public java.lang.String getAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUTTYPE$18, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorOutType" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUTTYPE$18, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorOutType" element
     */
    public boolean isSetAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTOROUTTYPE$18) != 0;
        }
    }
    
    /**
     * Sets the "adaptorOutType" element
     */
    public void setAdaptorOutType(java.lang.String adaptorOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUTTYPE$18, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTOROUTTYPE$18);
            }
            target.setStringValue(adaptorOutType);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorOutType" element
     */
    public void xsetAdaptorOutType(org.apache.xmlbeans.XmlString adaptorOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUTTYPE$18, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTOROUTTYPE$18);
            }
            target.set(adaptorOutType);
        }
    }
    
    /**
     * Unsets the "adaptorOutType" element
     */
    public void unsetAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTOROUTTYPE$18, 0);
        }
    }
    
    /**
     * Gets the "schemaIn" element
     */
    public java.lang.String getSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAIN$20, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaIn" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAIN$20, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaIn" element
     */
    public boolean isSetSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAIN$20) != 0;
        }
    }
    
    /**
     * Sets the "schemaIn" element
     */
    public void setSchemaIn(java.lang.String schemaIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAIN$20, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAIN$20);
            }
            target.setStringValue(schemaIn);
        }
    }
    
    /**
     * Sets (as xml) the "schemaIn" element
     */
    public void xsetSchemaIn(org.apache.xmlbeans.XmlString schemaIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAIN$20, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAIN$20);
            }
            target.set(schemaIn);
        }
    }
    
    /**
     * Unsets the "schemaIn" element
     */
    public void unsetSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAIN$20, 0);
        }
    }
    
    /**
     * Gets the "schemaInType" element
     */
    public java.lang.String getSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAINTYPE$22, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaInType" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAINTYPE$22, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaInType" element
     */
    public boolean isSetSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAINTYPE$22) != 0;
        }
    }
    
    /**
     * Sets the "schemaInType" element
     */
    public void setSchemaInType(java.lang.String schemaInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAINTYPE$22, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAINTYPE$22);
            }
            target.setStringValue(schemaInType);
        }
    }
    
    /**
     * Sets (as xml) the "schemaInType" element
     */
    public void xsetSchemaInType(org.apache.xmlbeans.XmlString schemaInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAINTYPE$22, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAINTYPE$22);
            }
            target.set(schemaInType);
        }
    }
    
    /**
     * Unsets the "schemaInType" element
     */
    public void unsetSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAINTYPE$22, 0);
        }
    }
    
    /**
     * Gets the "adaptorIn" element
     */
    public java.lang.String getAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORIN$24, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorIn" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORIN$24, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorIn" element
     */
    public boolean isSetAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTORIN$24) != 0;
        }
    }
    
    /**
     * Sets the "adaptorIn" element
     */
    public void setAdaptorIn(java.lang.String adaptorIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORIN$24, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTORIN$24);
            }
            target.setStringValue(adaptorIn);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorIn" element
     */
    public void xsetAdaptorIn(org.apache.xmlbeans.XmlString adaptorIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORIN$24, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTORIN$24);
            }
            target.set(adaptorIn);
        }
    }
    
    /**
     * Unsets the "adaptorIn" element
     */
    public void unsetAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTORIN$24, 0);
        }
    }
    
    /**
     * Gets the "adaptorInType" element
     */
    public java.lang.String getAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORINTYPE$26, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorInType" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORINTYPE$26, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorInType" element
     */
    public boolean isSetAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTORINTYPE$26) != 0;
        }
    }
    
    /**
     * Sets the "adaptorInType" element
     */
    public void setAdaptorInType(java.lang.String adaptorInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORINTYPE$26, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTORINTYPE$26);
            }
            target.setStringValue(adaptorInType);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorInType" element
     */
    public void xsetAdaptorInType(org.apache.xmlbeans.XmlString adaptorInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORINTYPE$26, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTORINTYPE$26);
            }
            target.set(adaptorInType);
        }
    }
    
    /**
     * Unsets the "adaptorInType" element
     */
    public void unsetAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTORINTYPE$26, 0);
        }
    }
}
